package yesjava;

import org.junit.Test;

import java.util.*;

public class MyTest {
    /**
     * 数组的使用，最大弊端 : 定长
     */
    @Test
    public void test1() {
        Person p1 = new Person("p1");
        Person p2 = new Person("p2");
        Person p3 = new Person("p3");
        Person p4 = new Person("p4");
        Person p5 = new Person("p5");

        Person[] arr = new Person[5];
        arr[0] = p1;
        arr[1] = p4;
        arr[2] = p3;
        arr[3] = p2;
        arr[4] = p5;
        Person p6 = new Person("p6");
        Person p7 = new Person("p7");

        Person[] arrNew = new Person[arr.length + arr.length / 2];
       /* for (int i = 0; i < arr.length; i++) {
            arrNew[i] = arr[i];
        }*/
        System.arraycopy(arr, 0, arrNew, 0, arr.length);
        arrNew[arr.length] = p6;
        arrNew[arr.length + 1] = p7;
        arr = arrNew;
        System.out.println("展示所有的数据(遍历)===============");
        for (Person person : arr) {
            System.out.println(person);
        }


    }

    /**
     * List 使用
     */
    @Test
    public void test2() {
        //有序，可重复
        List<String> list =  new LinkedList<>(); //new ArrayList<>();
        list.add("天");list.add("神");list.add("地");
        list.add("人");list.add("神");list.add("鬼");
        //list.add(55);
      /*  System.out.println(list.size());
        System.out.println(list.get(2));*/
//      List  遍历方式1: fori 循环
/*        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //      List  遍历方式2: forEach 循环
        for (String each : list) {
            System.out.println(each);
        }*/

//        List  遍历方式3: 迭代器 遍历
       /* Iterator<String> ita = list.iterator();
        while(ita.hasNext()){
            String each = ita.next();
            System.out.println(each);
        }*/

       /* for( Iterator<String> ita = list.iterator();ita.hasNext() ;){
            String each = ita.next();
            *//*System.out.println(each);*//*
            if(each.equals("地")){
                ita.remove();
            }
        }*/

    /*    for (int i = 0; i < list.size(); i++) { //fori 循环，remove(i)
            String s = list.get(i);
            if(s.equals("人")){
//                list.remove(s); //有问题
                list.remove(i);
            }
        }*/
        System.out.println("====================================");
        for (String s : list) {
            System.out.println(s);
        }



    }

    /**
     * Set 使用
     */
    @Test
    public void test3() {

        //无序，不重复:
        // Set 和List 最基本的区别: List 有get(), add() 返回值总是true； Set的add() 可能为false
        Set<String> set = new HashSet<>();
        boolean success =  set.add("天");
        success =  set.add("人");
        success =  set.add("地");
        success =  set.add("鬼");
        success =  set.add("神");
        success =  set.add("人");
        System.out.println(set.size());
//        System.out.println(list.get(2));

 /*         //      Set  遍历方式1: forEach 循环
        for (String each : set) {
            System.out.println(each);
        }*/

//        List  遍历方式3: 迭代器 遍历
       /* Iterator<String> ita = set.iterator();
        while(ita.hasNext()){
            String each = ita.next();
            System.out.println(each);
        }*/

        for( Iterator<String> ita = set.iterator();ita.hasNext() ;){
            String each = ita.next();
            if(each.equals("地")){
                ita.remove();
            }
        }

    /*    for (int i = 0; i < list.size(); i++) { //fori 循环，remove(i)
            String s = list.get(i);
            if(s.equals("人")){
//                list.remove(s); //有问题
                list.remove(i);
            }
        }*/
        System.out.println("====================================");
        for (String s : set) {
            System.out.println(s);
        }

    }

    /**
     * Map 使用
     */
    @Test
    public void test4() {
//        key  value : key 不能重复，当key相同的时候覆盖
        Map<String,Object> map = new HashMap();
        map.put("001","张三");
        map.put("002","李四") ;
        map.put("003","王五") ;
        map.put("004","赵柳") ;
        map.put("005","黄帝") ;
        map.put("005","平民") ;
        map.put("006","刘柳") ;
//        map.remove("003");
        map.clear();
      /*  System.out.println(map.size());
        System.out.println(map.get("005"));*/

//      Map 遍历的第一种方式：先拿左边，遍历左边拿右边
//        Set<String> keys = map.keySet();
        for (String key : map.keySet()) {
            System.out.println(key + "/" + map.get(key));
        }
        System.out.println("=====================================");
//        Map 遍历的第二种方式：先遍历每一行，分别获取 key 和 value
        Set<Map.Entry<String, Object>> entries = map.entrySet();
        for (Map.Entry<String, Object> entry : entries) {
            System.out.println(entry.getKey() + " : "+ entry.getValue());
        }




    }


    /**
     * 自然排序  Comparable
     * 和 比较器 Comparator  , 优先级高
     */

    @Test
    public void test5(){
        List<Person> list = new ArrayList<>();
        list.add(new Person("张三",25));
        list.add(new Person("李三",18));
        list.add(new Person("黄三",7));
        list.add(new Person("刘三",85));
        list.add(new Person("邓三",32));


//        Collections.sort(list);//升序
        Collections.sort(list, new Comparator<Person>() {// 降序
            @Override
            public int compare(Person p1, Person p2) {
                return p2.getAge() - p1.getAge();
            }
        });
//        Collections.sort(list);// 排序, Collections.shuffle(list); 随机打乱


        for (Person person : list) {
            System.out.println(person);
        }

    }


    /**
     * Set 判断两个对象是否相同的依据是什么
     * 先比较 hashcode , 如果hashCode 不同，直接认为两个对象不一样
     *  如果hashCode 相同，再根据equals 判断对象是否相同。
     */
    @Test
    public void test6(){
        Set<Person> set = new HashSet<>();
        Person p1 = new Person("hkx", 33);
        Person p2 = new Person("hkx",33);
        set.add(p1);
        set.add(p2);
        System.out.println(p1.equals(p2)); //

        for (Person person : set) {
            System.out.println(person);
        }
    }



    /*
    TreeSet : 判断两个对象是否相同的依据只有一个:  compare 返回值
//     compare  > hashcode > equals
     */
    @Test
    public void test7(){  // TreeSet
        // 需求：集合中的元素排序，不可重复
        SortedSet<Cat> cats = new TreeSet<>(new Comparator<Cat>() {
            public int compare(Cat cat1, Cat cat2) {
                return cat1.getAge() - cat2.getAge();
            }
        });
        cats.add(new Cat("红色",25));
        cats.add(new Cat("黄色",125));
        cats.add(new Cat("蓝色",125));// 蓝色，125   进不去
        cats.add(new Cat("黄色",99));  // 黄色 99
        cats.add(new Cat("黑色",126));

    /*    cats.add(new Cat("黑色",457));
        cats.add(new Cat("黑色",74));
        cats.add(new Cat("黑色",365));*/
//        Collections.sort(cats);

        for (Cat cat : cats) {
            System.out.println(cat);
        }
    }


    @Test
    public void test8(){
        Map<Cat, Object> map = new TreeMap<>();//  TreeMap  的key 类型必须具备自然排序的能力
        map.put(new Cat("黄",85),"11");
        map.put(new Cat("肉",95),"11");
    }


    /**
     * 演示一段古代的代码，大家只需要看到不要觉得自己落后！
     */
    @Test
    public void test9(){
        Vector<String> vector = new Vector<>(); //用法和 ArrayList 一致，差别：Vector 是线程安全的， ArrayList 是不安全的
        vector.add("中国");
        vector.add("美国");
        vector.add("日本");
        vector.add("泰国");
        /*for(Iterator<String> ita = strs.iterator(); ita.hasNext();){
            String each = ita.next();
            System.out.println(each);
        }*/
        Enumeration<String> elements = ((Vector<String>) vector).elements();// 看到古代的代码不要惊讶*/
        while (elements.hasMoreElements()){
            String each = elements.nextElement();
            System.out.println(each);
        }


    }



    /**
     * StringBuilder  和 StringBuffer
     * ArrayList  和 Vector
     * HashMap 和 Hashtable
     */

}
